home *** CD-ROM | disk | FTP | other *** search
/ Collection of Internet / Collection of Internet.iso / infosrvr / dev / www_talk.930 / 000375_connolly@pixel.convex.com _Sat Nov 21 06:03:10 1992.msg < prev    next >
Internet Message Format  |  1994-01-24  |  20KB
  1. Return-Path: <connolly@pixel.convex.com>
  2. Received: from dxmint.cern.ch by  nxoc01.cern.ch  (NeXT-1.0 (From Sendmail 5.52)/NeXT-2.0)
  3.     id AA05950; Sat, 21 Nov 92 06:03:10 MET
  4. Received: by dxmint.cern.ch (dxcern) (5.57/3.14)
  5.     id AA17366; Sat, 21 Nov 92 06:15:53 +0100
  6. Received: from pixel.convex.com by convex.convex.com (5.64/1.35)
  7.     id AA00842; Fri, 20 Nov 92 23:14:38 -0600
  8. Received: by pixel.convex.com (5.64/1.28)
  9.     id AA15421; Fri, 20 Nov 92 23:14:35 -0600
  10. Date: Fri, 20 Nov 92 23:14:35 -0600
  11. From: connolly@pixel.convex.com (Dan Connolly)
  12. Message-Id: <9211210514.AA15421@pixel.convex.com>
  13. Mime-Version: 1.0
  14. To: www-talk@nxoc01.cern.ch
  15. Subject: HTML spec part 1
  16. Cc: connolly@pixel.convex.com
  17. Content-Type: multipart/mixed;
  18.     boundary="PART.BOUNDARY.25512.15400.pixel.722322875.1"
  19.  
  20. > THIS IS A MESSAGE IN 'MIME' FORMAT.  Your mail reader does not support MIME.
  21. > Some parts of this will be readable as plain text.
  22. > To see the rest, you will need to upgrade your mail reader.
  23.  
  24. --PART.BOUNDARY.25512.15400.pixel.722322875.1
  25. Content-type: text/plain
  26. Content-Transfer-Encoding: quoted-printable
  27.  
  28. <TITLE>HyperText Mark-up Language</TITLE>
  29. <H1>Text and Markup</H1>
  30. This is an explanation of SGML syntax as it applies to HTML. It is design=
  31. ed to take section 7, "Element Structure" and reduce it fromthe abstract =
  32. system that is SGML to a concrete languag, HTML.<P>
  33. <H2><A NAME=3D"Tags">Tags</A>
  34. </H2>
  35. The characters in an SGML document are organized into a heirarchy of elem=
  36. ents by the use of tags. An HTML tag has the form<P>
  37. <DL><DT>start tag<DD>"<" name s+ attribute* s* ">"<DT>end tag<DD>"<=
  38. /" name s* ">"<DT>name<DD>letter (letter | digit){0,7}<DT>For example,</D=
  39. L>
  40. <XMP><Title>Here's the title of the Document</title></XMP>
  41. <XMP><h1 >A Heading</h1></XMP>
  42. <XMP><a NAME=3Dfoo>This text is the content of an A element.</a></XMP>
  43. <XMP><A HREF=3D"http://info.cern.ch/hypertext/WWW/TheProject.html"></XMP>=
  44.  
  45. <XMP>This text is a link to the WWW documentation. </a></XMP>
  46. Element names are not case sensitive. They are restricted to eight charac=
  47. ters or less.<P>
  48. <H4>Open Issue: Length of Names</H4>
  49. If we use the default SGML declaration, names are restricted to eight cha=
  50. racters. Some SGML parsers don't support other SGML declarations.<P>
  51. But most do, these days most SGML applications use a declaration with a l=
  52. arger value of NAMELEN.<P>
  53. The length of an attribute value literal is similarly limited to 240 char=
  54. acters. This might be a problem with long URLs. I think we should change =
  55. it.<P>
  56. <H2>Attributes</H2>
  57. Some elements have associated attributes. The start tag specifies the val=
  58. ues of the attributes for an element.<P>
  59. <DL><DT>attribute<DD>name s* "=3D" s* (token|literal)<DT>token<DD>(letter=
  60. |digit){1,8}<DT>letter<DD>[a-zA-Z]<DT>digit<DD>[0-9]<DT>literal<DD>'"' [^=
  61. "]{0,240} '"' | "'" [^']{0,240} "'"</DL>
  62. Each attribute of each element has a declared type. <P>
  63. <H4>Open Issue: Anchor Names: NMTOKEN or ID?</H4>
  64. The names of anchors within an HTML document should be unique. We can use=
  65.  the SGML ID mechanism to specify this.<P>
  66. But SGML IDs are names; that is, they start with a letter. Many HTML prod=
  67. ucers use numbers for anchor names.<P>
  68. <H4>Open Issue: Interpretation of Literals</H4>
  69. Section 7.9.3 of the SGML standard states<P>
  70. <UL><LI>An attribute value literal is interpreted as an attribute value b=
  71. y replacing references within it, ignoring Ee and RS, and replacing RE or=
  72.  SEPCHAR with SPACE.</UL>
  73. For the SGML-impared, Ee is Entity End (like EOF); RS is '\n'; RE is '\r'=
  74. ; SEPCHAR is '\t' and SPACE is ' '.<P>
  75. Since to date there are no HTML attributes containing newlines or spaces,=
  76.  that is not much of an issue.<P>
  77. But replacement of literals is. For one thing, this creates an interactio=
  78. n between the syntax of URLs and SGML syntax. We could resolve this issue=
  79.  by removing '&' from <A HREF=3D"http://info.cern.ch/hypertext/WWW/Ad=
  80. dressing/BNF.html#xalpha">the URL syntax</A>
  81. =2E<P>
  82. <H4>Historical Note</H4>
  83. The NeXT implementation of the WWW browser, responsible for the creation =
  84. of much of the existing HTML, does not surround attribute literals with q=
  85. uotes. These productions describe the syntax produced by the NeXT:<P>
  86. <DL><DT>NXattribute<DD>name "=3D" NXliteral<DT>NXliteral<DD> [^ >]+</DL>
  87. <H2>Normal Text: #PCDATA</H2>
  88. The symbol #PCDATA stands for parsed character data, the normal text char=
  89. acters in an SGML document.<P>
  90. The text consists of a stream of lines.The division into lines has no sig=
  91. nificance apart from indicating a word end.<P>
  92. The following character sequences are recognized as markup in #PCDATA:<P>=
  93.  
  94. <DL><DT><[a-zA-Z]<DD>"<" serves as the Start Tag Open delimiter whe=
  95. n followed by a letter. It is used to introduct <A HREF=3D"#Tags">tags</A=
  96. >
  97.  that start elements.<DT></[a-zA-Z]<DD>"</" serves as the End Tag O=
  98. pen delimiter when followed by a letter. It is used to introduce tags tha=
  99. t terminate elements.<DT><!(--)([A-Za-z])([)<DD>"<!" serves as the =
  100. Markup Declaration Open delimiter when followed by a letter or "--" or "[=
  101. ". It has several uses in SGML. The only purpose it serves in HTML is to =
  102. introduce comments.<DT>&[a-zA-z]<DD>"&" serves as the Entity Refe=
  103. rence Open delimiterwhen followed by a letter. It is used to introduce en=
  104. tities, or "macros." <DT>&#[0-9A-Za-z]<DD>"&#" followed by a lett=
  105. er or a digit is the Character Reference Open delimiter. SGML idioms incl=
  106. ude things like "&#168;" and "&#SPACE;". It is not used in HTML.<=
  107. DT>]]><DD>"]]" when followed by ">" is Marked Section Close. While marked=
  108.  sections are not used by SGML, this sequence of characters is recognized=
  109.  and reported as an error by conforming SGML parsers.</DL>
  110. <H4>Note to HTML Producers</H4>
  111. Note that conforming SGML parsers will treat "&", "<", "</", an=
  112. d "<!" as normal text characters when they are not followed by a lette=
  113. r. HTML producers are discouraged from taking advantage of this feature.<=
  114. P>
  115. All occurrences of the characters '&' and '<' should be represente=
  116. d by <A HREF=3D"#Entities">entities</A>
  117. =2E The marked section close delimiter can be avoided if all occurrences =
  118. of '>' are represented by entities.<P>
  119.  While the division of the stream of characters into lines is arbitrary, =
  120. the recommended line length is 72 characters in order to allow the text t=
  121. o be passed through systems which can only handle text with a limited lin=
  122. e length.<P>
  123. <H2>Literal Text: #RCDATA</H2>
  124. The symbol #RCDATA stands for replaceable character data, the text withou=
  125. t tags in an SGML document. It is used in HTML for sections where line br=
  126. eaks and character widths are significant.<P>
  127. Only the entity reference and end tag open delimiters are recognized in #=
  128. RCDATA.<P>
  129. Replaceable character data should be displayed in a fixed width font, so =
  130. that any formatting done by character spacing on successive lines will be=
  131.  maintained.<P>
  132. The ASCII Horizontal Tab (HT) character should be interpreted as the smal=
  133. lest positive nonzero number of spaces which will leave the number of cha=
  134. racters so far on the line as a multiple of 8. Its use is not recommended=
  135.  however.<P>
  136. <H4>Historical Note</H4>
  137. The original definition of literal text is not representable in SGML. Fro=
  138. m <A HREF=3D"http://info.cern.ch/hypertext/WWW/MarkUp/Tags.html">Tags use=
  139. d in HTML</A>
  140. :<P>
  141. <UL><LI>The text may contain any ISO Latin printable characters, includin=
  142. g the tag opener, so long as it does not contain the closing tag in full.=
  143.  </UL>
  144. But in section 7.6 of the SGML standard:<P>
  145. <UL><LI>The content of an element declared to be character data or replac=
  146. eable character data is terminated only by an etago delimiter-in-context =
  147. (which need not open a valid end-tag) ... .</UL>
  148. This definition is a compromise: it allows most markup to be ignored, but=
  149.  where the string "</" is needed, it can be represented as "&lt;/"=
  150. =2E We will probaly end up with some systems that display "&lt;/" rat=
  151. her than "</".<P>
  152. <H2><A NAME=3D"Entities">Entities</A>
  153. </H2>
  154. In order to include characters that would otherwise be treated as markup,=
  155.  SGML entity references refer to arbitrary sequences of characters. An HT=
  156. ML entity reference has the form:<P>
  157. <DL><DT>entity reference<DD>"&" name ";"<DT>Entity names are case sen=
  158. sitive.</DL>
  159. <H4>Open Issue: Character Set</H4>
  160. The default SGML declaration specifies ISO 646-1983 as the character set.=
  161.  I believe it's straight forward to specify ISO Latin 1 in the SGML decla=
  162. ration for HTML, but it's not clear that this is a good idea.<P>
  163. The SGML standard includes a set of entities for ISO Latin 1 characters a=
  164. s public text. For example, &OElig is the OE ligature. If we include =
  165. these entities in the HTML DTD, we could support Latin 1 characters while=
  166.  maintaining a 7 bit language. This would require a table of the entity n=
  167. ames in WWW clients.<P>
  168.  
  169.  
  170. --PART.BOUNDARY.25512.15400.pixel.722322875.1
  171. Content-type: text/plain
  172.  
  173. /*
  174. Copyright (c) 1991 Bell Communications Research, Inc. (Bellcore)
  175.  
  176. Permission to use, copy, modify, and distribute this material 
  177. for any purpose and without fee is hereby granted, provided 
  178. that the above copyright notice and this permission notice 
  179. appear in all copies, and that the name of Bellcore not be 
  180. used in advertising or publicity pertaining to this 
  181. material without the specific, prior written permission 
  182. of an authorized representative of Bellcore.  BELLCORE 
  183. MAKES NO REPRESENTATIONS ABOUT THE ACCURACY OR SUITABILITY 
  184. OF THIS MATERIAL FOR ANY PURPOSE.  IT IS PROVIDED "AS IS", 
  185. WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.
  186. */
  187. #include <stdio.h>
  188.  
  189. #define BASE64 1
  190. #define QP 2 /* quoted-printable */
  191.  
  192. main(argc, argv)
  193. int argc;
  194. char **argv;
  195. {
  196.     int encode = 1, which = BASE64, i;
  197.     FILE *fp = stdin;
  198.  
  199.     for (i=1; i<argc; ++i) {
  200.         if (argv[i][0] == '-') {
  201.             switch (argv[i][1]) {
  202.                 case 'u':
  203.                     encode = 0;
  204.                     break;
  205.                 case 'q':
  206.                     which = QP;
  207.                     break;
  208.                 case 'b':
  209.                     which = BASE64;
  210.                     break;
  211.         default:
  212.                     fprintf(stderr,
  213.                        "Usage: mmencode [-u] [-q] [-b] [file name]\n");
  214.                     exit(-1);
  215.             }
  216.         } else {
  217.             fp = fopen(argv[i], "r");
  218.             if (!fp) {
  219.                 perror(argv[i]);
  220.                 exit(-1);
  221.             }
  222.         }
  223.     }
  224.     if (which == BASE64) {
  225.         if (encode) to64(fp, stdout); else from64(fp, stdout, NULL, 0);
  226.     } else {
  227.         if (encode) toqp(fp, stdout); else fromqp(fp, stdout, NULL, 0);
  228.     }
  229.     return(0);
  230. }
  231.  
  232.  
  233. --PART.BOUNDARY.25512.15400.pixel.722322875.1
  234. Content-type: text/plain
  235.  
  236. /*
  237. Copyright (c) 1991 Bell Communications Research, Inc. (Bellcore)
  238.  
  239. Permission to use, copy, modify, and distribute this material 
  240. for any purpose and without fee is hereby granted, provided 
  241. that the above copyright notice and this permission notice 
  242. appear in all copies, and that the name of Bellcore not be 
  243. used in advertising or publicity pertaining to this 
  244. material without the specific, prior written permission 
  245. of an authorized representative of Bellcore.  BELLCORE 
  246. MAKES NO REPRESENTATIONS ABOUT THE ACCURACY OR SUITABILITY 
  247. OF THIS MATERIAL FOR ANY PURPOSE.  IT IS PROVIDED "AS IS", 
  248. WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.
  249. */
  250. #include <stdio.h>
  251. #include <ctype.h>
  252. #include <config.h>
  253.  
  254. extern char *index();
  255. static char basis_64[] =
  256.    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  257.  
  258. static char index_64[128] = {
  259.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  260.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  261.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
  262.     52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-1,-1,
  263.     -1, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
  264.     15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
  265.     -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
  266.     41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
  267. };
  268.  
  269. #define char64(c)  (((c) < 0 || (c) > 127) ? -1 : index_64[(c)])
  270.  
  271. /*
  272. char64(c)
  273. char c;
  274. {
  275.     char *s = (char *) index(basis_64, c);
  276.     if (s) return(s-basis_64);
  277.     return(-1);
  278. }
  279. */
  280.  
  281. to64(infile, outfile) 
  282. FILE *infile, *outfile;
  283. {
  284.     int c1, c2, c3, ct=0;
  285.     while ((c1 = getc(infile)) != EOF) {
  286.         c2 = getc(infile);
  287.         if (c2 == EOF) {
  288.             output64chunk(c1, 0, 0, 2, outfile);
  289.         } else {
  290.             c3 = getc(infile);
  291.             if (c3 == EOF) {
  292.                 output64chunk(c1, c2, 0, 1, outfile);
  293.             } else {
  294.                 output64chunk(c1, c2, c3, 0, outfile);
  295.             }
  296.         }
  297.         ct += 4;
  298.         if (ct > 71) {
  299.             putc('\n', outfile);
  300.             ct = 0;
  301.         }
  302.     }
  303.     if (ct) putc('\n', outfile);
  304.     fflush(outfile);
  305. }
  306.  
  307. output64chunk(c1, c2, c3, pads, outfile)
  308. FILE *outfile;
  309. {
  310.     putc(basis_64[c1>>2], outfile);
  311.     putc(basis_64[((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4)], outfile);
  312.     if (pads == 2) {
  313.         putc('=', outfile);
  314.         putc('=', outfile);
  315.     } else if (pads) {
  316.         putc(basis_64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)], outfile);
  317.         putc('=', outfile);
  318.     } else {
  319.         putc(basis_64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)], outfile);
  320.         putc(basis_64[c3 & 0x3F], outfile);
  321.     }
  322. }
  323.  
  324. PendingBoundary(s, Boundaries, BoundaryCt)
  325. char *s;
  326. char **Boundaries;
  327. int *BoundaryCt;
  328. {
  329.     int i;
  330.  
  331.     for (i=0; i < *BoundaryCt; ++i) {
  332.         if (!strncmp(s, Boundaries[i], strlen(Boundaries[i]))) {
  333.             char Buf[2000];
  334.             strcpy(Buf, Boundaries[i]);
  335.             strcat(Buf, "--\n");
  336.             if (!strcmp(Buf, s)) *BoundaryCt = i;
  337.             return(1);
  338.         }
  339.     }
  340.     return(0);
  341. }
  342.  
  343. from64(infile, outfile, boundaries, boundaryct) 
  344. FILE *infile, *outfile;
  345. char **boundaries;
  346. int *boundaryct;
  347. {
  348.     int c1, c2, c3, c4;
  349.     int newline = 1, DataDone = 0;
  350.  
  351.     while ((c1 = getc(infile)) != EOF) {
  352.         if (isspace(c1)) {
  353.             if (c1 == '\n') {
  354.                 newline = 1;
  355.             } else {
  356.                 newline = 0;
  357.             }
  358.             continue;
  359.         }
  360.         if (newline && boundaries && c1 == '-') {
  361.             char Buf[200];
  362.             /* a dash is NOT base 64, so all bets are off if NOT a boundary */
  363.             ungetc(c1, infile);
  364.             fgets(Buf, sizeof(Buf), infile);
  365.             if (boundaries
  366.                  && (Buf[0] == '-')
  367.                  && (Buf[1] == '-')
  368.                  && PendingBoundary(Buf, boundaries, boundaryct)) {
  369.                 return;
  370.             }
  371.             fprintf(stderr, "Ignoring unrecognized boundary line: %s\n", Buf);
  372.             continue;
  373.         }
  374.         if (DataDone) continue;
  375.         newline = 0;
  376.         do {
  377.             c2 = getc(infile);
  378.         } while (c2 != EOF && isspace(c2));
  379.         do {
  380.             c3 = getc(infile);
  381.         } while (c3 != EOF && isspace(c3));
  382.         do {
  383.             c4 = getc(infile);
  384.         } while (c4 != EOF && isspace(c4));
  385.         if (c2 == EOF || c3 == EOF || c4 == EOF) {
  386.             fprintf(stderr, "Premature EOF!\n");
  387.             return;
  388.         }
  389.         if (c1 == '=' || c2 == '=') {
  390.             DataDone=1;
  391.             continue;
  392.         }
  393.         c1 = char64(c1);
  394.         c2 = char64(c2);
  395.         putc(((c1<<2) | ((c2&0x30)>>4)), outfile);
  396.         if (c3 == '=') {
  397.             DataDone = 1;
  398.         } else {
  399.             c3 = char64(c3);
  400.             putc((((c2&0XF) << 4) | ((c3&0x3C) >> 2)), outfile);
  401.             if (c4 == '=') {
  402.                 DataDone = 1;
  403.             } else {
  404.                 c4 = char64(c4);
  405.                 putc((((c3&0x03) <<6) | c4), outfile);
  406.             }
  407.         }
  408.     }
  409. }
  410.  
  411. static char basis_hex[] = "0123456789ABCDEF";
  412. static char index_hex[128] = {
  413.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  414.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  415.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  416.      0, 1, 2, 3,  4, 5, 6, 7,  8, 9,-1,-1, -1,-1,-1,-1,
  417.     -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  418.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  419.     -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  420.     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1
  421. };
  422.  
  423. #define hexchar(c)  (((c) < 0 || (c) > 127) ? -1 : index_hex[(c)])
  424.  
  425. /*
  426. hexchar(c)
  427. char c;
  428. {
  429.     char *s;
  430.     if (islower(c)) c = toupper(c);
  431.     s = (char *) index(basis_hex, c);
  432.     if (s) return(s-basis_hex);
  433.     return(-1);
  434. }
  435. */
  436.  
  437. toqp(infile, outfile) 
  438. FILE *infile, *outfile;
  439. {
  440.     int c, ct=0, prevc=255;
  441.     while ((c = getc(infile)) != EOF) {
  442.         if ((c < 32 && (c != '\n' && c != '\t'))
  443.              || (c == '=')
  444.              || (c >= 127)
  445.              /* Following line is to avoid single periods alone on lines,
  446.                which messes up some dumb smtp implementations, sigh... */
  447.              || (ct == 0 && c == '.')) {
  448.             putc('=', outfile);
  449.             putc(basis_hex[c>>4], outfile);
  450.             putc(basis_hex[c&0xF], outfile);
  451.             ct += 3;
  452.             prevc = 'A'; /* close enough */
  453.         } else if (c == '\n') {
  454.             if (prevc == ' ' || prevc == '\t') {
  455.                 putc('=', outfile); /* soft & hard lines */
  456.                 putc(c, outfile);
  457.             }
  458.             putc(c, outfile);
  459.             ct = 0;
  460.             prevc = c;
  461.         } else {
  462.             putc(c, outfile);
  463.             ++ct;
  464.             prevc = c;
  465.         }
  466.         if (ct > 72) {
  467.             putc('=', outfile);
  468.             putc('\n', outfile);
  469.             ct = 0;
  470.             prevc = '\n';
  471.         }
  472.     }
  473.     if (ct) {
  474.         putc('=', outfile);
  475.         putc('\n', outfile);
  476.     }
  477. }
  478.  
  479. fromqp(infile, outfile, boundaries, boundaryct) 
  480. FILE *infile, *outfile;
  481. char **boundaries;
  482. int *boundaryct;
  483. {
  484.     int c1, c2, sawnewline = 1;
  485.  
  486.     while ((c1 = getc(infile)) != EOF) {
  487.         if (sawnewline && boundaries && (c1 == '-')) {
  488.             char Buf[200], *s;
  489.  
  490.             ungetc(c1, infile);
  491.             fgets(Buf, sizeof(Buf), infile);
  492.             if (boundaries
  493.                  && (Buf[0] == '-')
  494.                  && (Buf[1] == '-')
  495.                  && PendingBoundary(Buf, boundaries, boundaryct)) {
  496.                 return;
  497.             }
  498.             /* Not a boundary, now we must treat THIS line as q-p, sigh */
  499.             for (s=Buf; *s; ++s) {
  500.                 if (*s == '=') {
  501.                     if (!*++s) break;
  502.                     if (*s == '\n') {
  503.                         /* ignore it */
  504.                         sawnewline = 1;
  505.                     } else {
  506.                         c1 = hexchar(*s);
  507.                         if (!*++s) break;
  508.                         c2 = hexchar(*s);
  509.                         putc(c1<<4 | c2, outfile);
  510.                     }
  511.                 } else {
  512.                     putc(*s, outfile);
  513.                 }
  514.             }
  515.         } else {
  516.             sawnewline = (c1 == '\n') ? 1 : 0;
  517.             if (c1 == '=') {
  518.                 c1 = getc(infile);
  519.                 if (c1 == '\n') {
  520.                     /* ignore it */
  521.                     sawnewline = 1;
  522.                 } else {
  523.                     c2 = getc(infile);
  524.                     c1 = hexchar(c1);
  525.                     c2 = hexchar(c2);
  526.                     putc(c1<<4 | c2, outfile);
  527.                     if (c2 == '\n') sawnewline = 1;
  528.                 }
  529.             } else {
  530.                 putc(c1, outfile);
  531.             }
  532.         }
  533.     }
  534. }
  535.  
  536. --PART.BOUNDARY.25512.15400.pixel.722322875.1--